/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.pedidos.servidor.mb;

import br.com.pedidos.servidor.entity.Mesa;
import br.com.pedidos.servidor.entity.Pedido;
import br.com.pedidos.servidor.entity.PedidoProdutoQuantidade;
import br.com.pedidos.servidor.entity.Produto;
import br.com.pedidos.servidor.mb.model.PedidoDataModel;
import br.com.pedidos.servidor.mb.observer.MesaObservador;
import br.com.pedidos.servidor.mb.observer.PedidoObservado;
import br.com.pedidos.servidor.rn.MesaRN;
import br.com.pedidos.servidor.rn.PedidoProdutoQuantidadeRN;
import br.com.pedidos.servidor.rn.PedidoRN;
import br.com.pedidos.servidor.rn.ProdutoRN;
import br.com.pedidos.servidor.util.Constantes;
import br.com.pedidos.servidor.util.Monetario;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ValueChangeEvent;
import javax.faces.model.SelectItem;
import org.primefaces.push.EventBus;
import org.primefaces.push.EventBusFactory;

/**
 *
 * @author Weslley
 */
@ManagedBean
@SessionScoped
public class ControladorAtendimentoMB implements PedidoObservado, Serializable {

    private static final long serialVersionUID = 1L;
    private boolean atendimentoIniciado = false;
    private boolean visualizaHistorico = false;
    private String botaoAtendimento;

    private PedidoRN pedidoRN;
    private MesaRN mesaRN;
    private PedidoProdutoQuantidadeRN ppkRN;
    private ProdutoRN produtoRN;

    //Variáveis nova lógica controlador
    List<Pedido> listaPedidosPendentes;
    List<Pedido> listaPedidosFechandoConta;
    List<Pedido> listaPedidosHistorico;
    List<Pedido> listaPedidosEmPreparo;
    List<Pedido> listaPedidosEmAbertoPorMesa;
    private PedidoDataModel listaPedidoModel;

    private List<Produto> listaProdutosPedido;

    private Pedido pedidoEmAtendimento;

    //Salva as mesas em atendimento nesse map
    private HashMap<Integer, MesaObservador> mesaMap = new HashMap<>();

    private List<Pedido> pedidos;
    private List<SelectItem> listaPedidos;
    private List<Produto> listaProdutosPedidoMesa;

    private List<Mesa> listaMesasAtendimentoEmAberto;

    private PedidoDataModel listaPedidosHistoricoModel;

    private Mesa mesaAFechar;

    private Mesa mesaVazio = new Mesa();

    // Variável que é usada pra representar o número de atendimento dos pedidos.
    private Integer contNumeroPedidoAtendido;

    //Variável que exibe o valor total da conta da mesa que está sendo atendida.
    private float totalContaMesaAtendimento = 0;

    //Se for false, não exibe o total da mesa selecionada a ser detalhada, do
    //contrário, exibe.
    private boolean exibeTotal = false;

    public ControladorAtendimentoMB() {
        pedidoRN = new PedidoRN();
        mesaRN = new MesaRN();
        ppkRN = new PedidoProdutoQuantidadeRN();
        produtoRN = new ProdutoRN();
    }

    public void iniciaAtendimento() {
        FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Atendimento Iniciado!", null));
        RepositorioControlador.setControladorPedidoInstance(this);
        mesaMap = new HashMap<>();
        pedidos = new ArrayList<>();
        listaMesasAtendimentoEmAberto = new ArrayList<>();
        atendimentoIniciado = true;
        contNumeroPedidoAtendido = 1;
        verificaPedidosProntosParaHistorico();
        verificaMesasEmServico();
        verificaPedidosAguardandoConta();
        verificaPedidosPendentes();
        verificaPedidosEmPreparo();
        listarPedidosModel();
    }

    public String encerraAtendimento() {
        RepositorioControlador.removeControladorPedidoInstance();
        atendimentoIniciado = false;
        FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Atendimento Encerrado!", null));
        FacesContext.getCurrentInstance().getExternalContext().invalidateSession();
        return "/teste_balcao.jsf?faces-redirect=true";
    }

    //----------------------------- Métodos de ação do controlador
    /**
     * Método utilizado para alterar o status do pedido de "pendente" para "em
     * preparo". Joga esse pedido na listaPedidosEmPreparo e remove o mesmo da
     * listaPedidosPendentes.
     */
    public void atendePedido() throws IOException {
        pedidoEmAtendimento.setStatus(Constantes.EM_PREPARO);
        pedidoRN.atualizaPedido(pedidoEmAtendimento);

        listaPedidosEmPreparo.add(pedidoEmAtendimento);

        listaPedidosPendentes.remove(pedidoEmAtendimento);

        atualizaMesa(pedidoEmAtendimento.getMesa());
        pedidoEmAtendimento = null;
        listarPedidosModel();
    }

    /**
     * Método utilizado para alterar o status do pedido para "pronto" e
     * adicionar o mesmo na lista de histórico e removê-lo da lista de em
     * preparo.
     */
    public void informaPedidoPronto() {
        pedidoEmAtendimento.setStatus(Constantes.PRONTO);
        pedidoEmAtendimento.setMomentoAtendido(new Date());
        pedidoRN.atualizaPedido(pedidoEmAtendimento);

        listaPedidosHistorico.add(pedidoEmAtendimento);
        listaPedidosEmPreparo.remove(pedidoEmAtendimento);

        atualizaHistoricoDataModel();
        atualizaMesa(pedidoEmAtendimento.getMesa());
        pedidoEmAtendimento = null;
        listarPedidosModel();
    }

    /**
     * Método responsável por fechar a conta de uma mesa.
     *
     * Ação responsável por fechar a conta de uma mesa que tenha, previamente,
     * solicitado um pedido de conta no sistema.
     *
     */
    public void encerraConta() {
        Mesa m = mesaRN.mesaPorNumero(pedidoEmAtendimento.getMesa().getNumero());
        m.setStatus(Constantes.MESA_LIVRE);
        m.setQuantidadeTotal(0);
        mesaRN.atualizaMesa(m);

        listaPedidosFechandoConta.remove(pedidoEmAtendimento);

        removePedidosDoHistorico(m);
        salvaPedidoDeContaETotal(m);
        atualizaStatusPedidoAposFechaConta(m.getNumero());

        listaMesasAtendimentoEmAberto.remove(m);

        pedidoEmAtendimento = null;

        totalContaMesaAtendimento = 0;

        exibeTotal = false;

        listarPedidosModel();
        atualizaMesaLiberaPedido(m);
        atualizaMesa(m);
        removeObservador(m);
        limpaMesaEPedido();
        atualizaBalcao();

        //TODO: Terminar a lógica de fechar conta.
    }

    public void encerraContaNoBalcao() {
        mesaAFechar.setStatus(Constantes.MESA_LIVRE);
        mesaAFechar.setQuantidadeTotal(0);

        mesaRN.atualizaMesa(mesaAFechar);

        if (listaPedidosFechandoConta.isEmpty() == false) {
            Pedido pedidoASerRemovido = null;
            for (Pedido p : listaPedidosFechandoConta) {
                if (p.getMesa().getNumero() == mesaAFechar.getNumero()) {
                    p.setStatus(Constantes.ENCERRADO_ATENDIDO);
                    pedidoRN.atualizaPedido(p);
                    pedidoEmAtendimento = p;
                    salvaPedidoDeContaETotal(mesaAFechar);
                    pedidoASerRemovido = p;
                    break;
                }
            }
            if (pedidoASerRemovido != null) {
                listaPedidosFechandoConta.remove(pedidoASerRemovido);
            }
        } else {
            salvaPedidoDeContaETotal(mesaAFechar);
        }
        removePedidosDoHistorico(mesaAFechar);

        atualizaStatusPedidoAposFechaConta(mesaAFechar.getNumero());

        listaMesasAtendimentoEmAberto.remove(mesaAFechar);

        totalContaMesaAtendimento = 0;

        exibeTotal = false;

        listarPedidosModel();
        atualizaMesaLiberaPedido(mesaAFechar);
        atualizaMesa(mesaAFechar);
        removeObservador(mesaAFechar);
        limpaMesaEPedido();
        atualizaBalcao();

    }

    //--------------------- Métodos utilizados para informar ao controlador as solicitações dos clientes
    /**
     * Registra um observador para que possa ser feita as notificações a mesa
     * correta.
     *
     * @param id
     * @param obs
     */
    @Override
    public void registraMesaObservador(Integer id, MesaObservador obs) {
        boolean contemMesa = false;
        if (listaMesasAtendimentoEmAberto.isEmpty() == false) {
            for (Mesa m : listaMesasAtendimentoEmAberto) {
                if (m.getNumero() == id) {
                    contemMesa = true;
                    if (mesaMap.containsKey(id)) {
                    } else {
                        mesaMap.put(id, obs);
                    }
                    break;
                }
            }
            if (contemMesa == false) {
                listaMesasAtendimentoEmAberto.add(mesaRN.mesaPorNumero(id));
                if (mesaMap.containsKey(id)) {
                } else {
                    mesaMap.put(id, obs);
                }
            }
        } else {
            listaMesasAtendimentoEmAberto.add(mesaRN.mesaPorNumero(id));
            mesaMap.put(id, obs);
        }
    }

    @Override
    public void registraPedido(Pedido p) {
        listaPedidosPendentes.add(p);
        listarPedidosModel();
    }

    @Override
    public void cancelaPedido(Pedido p) {
        listaPedidosPendentes.remove(p);
        listarPedidosModel();
        atualizaMesa(p.getMesa());
    }

    @Override
    public void registraEncerraConta(Pedido p) {
        listaPedidosFechandoConta.add(p);

        listarPedidosModel();
        atualizaMesa(p.getMesa());
    }

    // ------------------------- Métodos responsáveis por listagens do controlador
    /**
     * Busca mesas com pedido em aberto.
     */
    private void verificaMesasEmServico() {
        listaMesasAtendimentoEmAberto = mesaRN.listaMesaComPedidosPendenteEmPreparoEPronto();
    }

    /**
     * Alimentar a listaPedidoModel.
     */
    private void listarPedidosModel() {
        List<Pedido> listaPedidosModel = new ArrayList<>();
        if (listaPedidosFechandoConta.isEmpty() == false) {
            listaPedidosModel.addAll(listaPedidosFechandoConta);
        }
        if (listaPedidosPendentes.isEmpty() == false) {
            listaPedidosModel.addAll(listaPedidosPendentes);
        }
        if (listaPedidosEmPreparo.isEmpty() == false) {
            listaPedidosModel.addAll(listaPedidosEmPreparo);
        }
        listaPedidoModel = new PedidoDataModel(listaPedidosModel);

        atualizaBalcao();
    }

    /**
     * Popula a lista de produtos de um determinado pedido.
     *
     * Recebe o pedido selecionado como parâmetro e cria uma lista de todos os
     * produtos com suas quantidades para serem exibidos na tela de detalhes do
     * pedido.
     *
     * @param p
     */
    public void exibeDetalhesPedido(Pedido p) {
        pedidoEmAtendimento = p;

        listaProdutosPedido = new ArrayList<>();

        if (pedidoEmAtendimento.getTipo().equalsIgnoreCase(Constantes.PEDIDO_CONTA)) {
            List<Pedido> listaPed = pedidoRN.listaPedidosEmPreparoEProntoPorMesa(p.getMesa().getNumero());

            List<PedidoProdutoQuantidade> listaPPKPedidos = new ArrayList<>();

            // Alimenta a lista de produtos por pedido feitos por uma mesa.
            for (Pedido ped : listaPed) {
                List<PedidoProdutoQuantidade> listaPedProdQtd = ppkRN.listaPPKPorPedido(ped.getId());

                for (PedidoProdutoQuantidade ppk : listaPedProdQtd) {
                    boolean produtoRepetido = false;
                    for (PedidoProdutoQuantidade ppkAux : listaPPKPedidos) {
                        if (ppkAux.getProduto().equals(ppk.getProduto())) {
                            ppkAux.setQuantidade(ppkAux.getQuantidade() + ppk.getQuantidade());
                            produtoRepetido = true;
                            break;
                        }
                    }
                    if (produtoRepetido == false) {
                        listaPPKPedidos.add(ppk);
                    }
                }
            }

            //Agora pega os elementos da lista de produtos anterior e passa os produtos pra lista
            //que será exibida no detalhe da conta.
            for (PedidoProdutoQuantidade ppk : listaPPKPedidos) {
                Produto prod = produtoRN.produtoPorId(ppk.getProduto().getId());
                prod.setQuantidadeVenda(ppk.getQuantidade());
                listaProdutosPedido.add(prod);
            }

            //Calcula o valor total da conta
            adicionaValorDoPedidoNoTotal(listaPPKPedidos);

            exibeTotal = true;
        } else {
            List<PedidoProdutoQuantidade> listaPedProdQtd = ppkRN.listaPPKPorPedido(p.getId());

            for (PedidoProdutoQuantidade ppk : listaPedProdQtd) {
                Produto prod = produtoRN.produtoPorId(ppk.getProduto().getId());
                prod.setQuantidadeVenda(ppk.getQuantidade());
                listaProdutosPedido.add(prod);
            }
            exibeTotal = false;
        }
    }

    public int renderizaBotaoAtendimento() {
        if (pedidoEmAtendimento != null && pedidoEmAtendimento.getStatus() != null) {
            if (pedidoEmAtendimento.getStatus().equalsIgnoreCase(Constantes.PENDENTE)) {
                return 0;
            } else if (pedidoEmAtendimento.getStatus().equalsIgnoreCase(Constantes.AGUARDO_CONTA)) {
                return 1;
            } else if (pedidoEmAtendimento.getStatus().equalsIgnoreCase(Constantes.EM_PREPARO)) {
                return 2;
            }
        }
        return 4;
    }

    public void renderizaBotaoHistorico() {
        visualizaHistorico = visualizaHistorico == false;
        atualizaBalcao();
    }

    /**
     * Método que lista os pedidos de uma mesa que não foi fechada previamente.
     *
     * @param e
     */
    public void listaPedidosMesaAFechar(ValueChangeEvent e) {
        mesaAFechar = (Mesa) e.getNewValue();

        if (mesaAFechar == null) {
            listaProdutosPedidoMesa = new ArrayList<>();
            exibeTotal = false;
        } else {
            pedidos = new ArrayList<>();
            pedidos = pedidoRN.listaPedidosAtendidosProntosEPendentesPorMesa(mesaAFechar.getNumero());
            exibeTotal = true;

            calculaTotalMesaAtendimento(pedidos);

            listaProdutosPedidoMesa = new ArrayList<>();

            concatenaPedidosComProdutosRepetidos(pedidos);

            atualizaBalcao();

            exibeTotal = true;
        }
    }

    //--------------------------- Métodos auxiliares
    private void salvaPedidoDeContaETotal(Mesa m) {
        if (pedidoEmAtendimento == null) {
            Pedido p = new Pedido();
            p.setMesa(m);
            p.setMomentoPedido(new Date());
            p.setMomentoAtendido(new Date());
            p.setStatus(Constantes.AGUARDO_CONTA);
            p.setTipo(Constantes.PEDIDO_CONTA);
            p.setTotal(totalContaMesaAtendimento);

            pedidoRN.salvaPedido(p);
        } else {
            pedidoEmAtendimento.setTotal(totalContaMesaAtendimento);

            pedidoRN.atualizaPedido(pedidoEmAtendimento);
        }

    }

    private void concatenaPedidosComProdutosRepetidos(List<Pedido> listaPedidos) {
        List<PedidoProdutoQuantidade> listaPedProdQtd = new ArrayList<>();
        for (Pedido pe : listaPedidos) {
            if (pe.getStatus().equalsIgnoreCase(Constantes.PENDENTE)) {
                //Não adiciona esse pedido.
            } else {
                listaPedProdQtd.addAll(ppkRN.listaPPKPorPedido(pe.getId()));
            }
        }
        for (PedidoProdutoQuantidade pedProdQtd : listaPedProdQtd) {
            Produto p = produtoRN.produtoPorId(pedProdQtd.getProduto().getId());

            p.setQuantidadeVenda(pedProdQtd.getQuantidade());

            if (listaProdutosPedidoMesa.contains(p)) {
                listaProdutosPedidoMesa.get(listaProdutosPedidoMesa.indexOf(p)).setQuantidadeVenda(p.getQuantidadeVenda());
            } else {
                listaProdutosPedidoMesa.add(p);
            }
        }
    }

    private void atualizaMesa(Mesa m) {
        if (mesaMap.isEmpty() == false && mesaMap.containsKey(m.getNumero())) {
            mesaMap.get(m.getNumero()).atualizaHistorico();
        } else {

        }
    }

    private void atualizaMesaLiberaPedido(Mesa m) {
        if (mesaMap.isEmpty() == false) {
            mesaMap.get(m.getNumero()).atualizaLiberaFazerPedido();
        }
    }

    private void atualizaBalcao() {
        EventBus eventBus = EventBusFactory.getDefault().eventBus();
        eventBus.publish("/atualizaPedido", new FacesMessage("Atualizando balcão"));
    }

    private void limpaMesaEPedido() {
        mesaAFechar = new Mesa();
        pedidos = new ArrayList<>();
        listaProdutosPedidoMesa = new ArrayList<>();
    }

    private void atualizaHistoricoDataModel() {
        listaPedidosHistoricoModel = new PedidoDataModel(listaPedidosHistorico);
    }

    private void removeObservador(Mesa m) {
        mesaMap.remove(m.getNumero());
    }

    private void encerraPedidoCancelado(Pedido p) {
        Pedido pedidoRecuperado = pedidoRN.pedidoPorId(p.getId());
        pedidoRecuperado.setStatus(Constantes.ENCERRADO_CANCELADO);
        pedidoRN.atualizaPedido(pedidoRecuperado);
    }

    private void encerraPedidoAtendido(Pedido p) {
        Pedido pedidoRecuperado = pedidoRN.pedidoPorId(p.getId());
        pedidoRecuperado.setStatus(Constantes.ENCERRADO_ATENDIDO);
        pedidoRN.atualizaPedido(pedidoRecuperado);
    }

    private synchronized void atualizaStatusPedidoAposFechaConta(int idMesa) {

        List<Pedido> listaPedidosMesaAberta = pedidoRN.listaPedidosPorMesaAberta(idMesa);

        for (Pedido p : listaPedidosMesaAberta) {
            if (p.getStatus().equalsIgnoreCase(Constantes.CANCELADO)) {
                encerraPedidoCancelado(p);
            } else if (p.getStatus().equalsIgnoreCase(Constantes.PENDENTE)) {
                encerraPedidoCancelado(p);
                if (listaPedidosPendentes.contains(p)) {
                    listaPedidosPendentes.remove(p);
                    listarPedidosModel();
                }
            } else {
                encerraPedidoAtendido(p);
                if (listaPedidosEmPreparo.contains(p)) {
                    listaPedidosEmPreparo.remove(p);
                    listarPedidosModel();
                }
            }
        }
    }

    private void removePedidosDoHistorico(Mesa m) {
        int j = listaPedidosHistorico.size();

        List<Pedido> listaPedARemover = new ArrayList<>();

        for (int i = 0; i < j; i++) {
            if (m.getNumero() == listaPedidosHistorico.get(i).getMesa().getNumero()) {
                listaPedARemover.add(listaPedidosHistorico.get(i));
            }
        }

        listaPedidosHistorico.removeAll(listaPedARemover);

        atualizaHistoricoDataModel();
    }

    /**
     * Calcula o total da mesa em atendimento. Faz o cálculo dos valores de cada
     * pedido feito por uma mesa e seta o valor final na variável
     * "totalContaMesaAtendimento".
     */
    private void calculaTotalMesaAtendimento(List<Pedido> listaPedidos) {
        totalContaMesaAtendimento = 0;
        for (Pedido p : listaPedidos) {
            if (p.getStatus().equalsIgnoreCase(Constantes.PENDENTE)) {
                //Não adiciona esse pedido.
            } else {
                List<PedidoProdutoQuantidade> listaPPK = ppkRN.listaPPKPorPedido(p.getId());
                adicionaValorDoPedidoNoTotal(listaPPK);
            }
        }
    }

    private void adicionaValorDoPedidoNoTotal(List<PedidoProdutoQuantidade> listaPPK) {
        for (PedidoProdutoQuantidade ppk : listaPPK) {
            totalContaMesaAtendimento = (totalContaMesaAtendimento + (ppk.getProduto().getPreco() * ppk.getQuantidade()));
        }
    }

    /**
     * Verifica se existem pedidos com status de pendente. Caso o servidor caia
     * por algum motivo, ainda será possível recuperar o estado das mesas no
     * momento que o problema ocorreu.
     */
    private void verificaPedidosPendentes() {
        listaPedidosPendentes = new ArrayList<>();
        listaPedidosPendentes = pedidoRN.listaPedidosPendentes();
    }

    /**
     * Verifica se existem pedidos aguardando conta. Caso o servidor caia por
     * algum motivo, ainda será possível recuperar o estado das mesas no momento
     * que o problema ocorreu.
     */
    private void verificaPedidosAguardandoConta() {
        listaPedidosFechandoConta = new ArrayList<>();
        listaPedidosFechandoConta = pedidoRN.listaPedidosAguardandoConta();
    }

    /**
     * Verifica se existem pedidos pronto. Caso o servidor caia por algum
     * motivo, ainda será possível recuperar o estado das mesas no momento que o
     * problema ocorreu.
     */
    private void verificaPedidosProntosParaHistorico() {
        listaPedidosHistorico = new ArrayList<>();
        listaPedidosHistorico = pedidoRN.listaPedidosPronto();
        atualizaHistoricoDataModel();
    }

    /**
     * Verifica se existem pedidos em preparo. Caso o servidor caia por algum
     * motivo, ainda será possível recuperar o estado das mesas no momento que o
     * problema ocorreu.
     */
    private void verificaPedidosEmPreparo() {
        listaPedidosEmPreparo = new ArrayList<>();
        listaPedidosEmPreparo = pedidoRN.listaPedidosEmPreparo();
    }

    public String retornaBackgroundColorPedido(String status) {
        switch (status) {
            case Constantes.PENDENTE:
                return "background-color: " + Constantes.AMARELO;
            case Constantes.EM_PREPARO:
                return "background-color: " + Constantes.VERDE;
            case Constantes.AGUARDO_CONTA:
                return "background-color: " + Constantes.AZUL;
            case Constantes.PRONTO:
                return "background-color: " + Constantes.CINZA;
            case Constantes.MESA_LIVRE:
                return "background-color: " + Constantes.BRANCO;
            default:
                return "";
        }
    }
    
    public void retornaPedidosEmAbertoPorMesa(Mesa m) {
        listaPedidosEmAbertoPorMesa = pedidoRN.listaPedidosEmPreparoEProntoPorMesa(m.getNumero());
        
        pedidos = new ArrayList<>();
        pedidos = pedidoRN.listaPedidosAtendidosProntosEPendentesPorMesa(m.getNumero());
        exibeTotal = true;

        calculaTotalMesaAtendimento(pedidos);

        listaProdutosPedidoMesa = new ArrayList<>();

        concatenaPedidosComProdutosRepetidos(pedidos);
    }

    //GETTERS AND SETTERS
    public String getTotalContaMesaAtendimentoMonetario() {
        if (totalContaMesaAtendimento != 0) {
            return Monetario.toMoney(new BigDecimal(totalContaMesaAtendimento));
        } else {
            return "";
        }
    }

    public boolean isAtendimentoIniciado() {
        return atendimentoIniciado;
    }

    public void setAtendimentoIniciado(boolean atendimentoIniciado) {
        this.atendimentoIniciado = atendimentoIniciado;
    }

    public boolean isVisualizaHistorico() {
        return visualizaHistorico;
    }

    public void setVisualizaHistorico(boolean visualizaHistorico) {
        this.visualizaHistorico = visualizaHistorico;
    }

    public String getBotaoAtendimento() {
        return botaoAtendimento;
    }

    public void setBotaoAtendimento(String botaoAtendimento) {
        this.botaoAtendimento = botaoAtendimento;
    }

    public List<Pedido> getPedidos() {
        return pedidos;
    }

    public void setPedidos(List<Pedido> pedidos) {
        this.pedidos = pedidos;
    }

    public List<SelectItem> getListaPedidos() {
        return listaPedidos;
    }

    public void setListaPedidos(List<SelectItem> listaPedidos) {
        this.listaPedidos = listaPedidos;
    }

    public List<Produto> getListaProdutosPedidoMesa() {
        return listaProdutosPedidoMesa;
    }

    public void setListaProdutosPedidoMesa(List<Produto> listaProdutosPedidoMesa) {
        this.listaProdutosPedidoMesa = listaProdutosPedidoMesa;
    }

    public boolean isExibeTotal() {
        return exibeTotal;
    }

    public void setExibeTotal(boolean exibeTotal) {
        this.exibeTotal = exibeTotal;
    }

    public List<Mesa> getListaMesasAtendimentoEmAberto() {
        return listaMesasAtendimentoEmAberto;
    }

    public void setListaMesasAtendimentoEmAberto(List<Mesa> listaMesasAtendimentoEmAberto) {
        this.listaMesasAtendimentoEmAberto = listaMesasAtendimentoEmAberto;
    }

    public Mesa getMesaVazio() {
        return mesaVazio;
    }

    public void setMesaVazio(Mesa mesaVazio) {
        this.mesaVazio = mesaVazio;
    }

    public Mesa getMesaAFechar() {
        return mesaAFechar;
    }

    public void setMesaAFechar(Mesa mesaAFechar) {
        this.mesaAFechar = mesaAFechar;
    }

    public float getTotalContaMesaAtendimento() {
        return totalContaMesaAtendimento;
    }

    public void setTotalContaMesaAtendimento(float totalContaMesaAtendimento) {
        this.totalContaMesaAtendimento = totalContaMesaAtendimento;
    }

    public PedidoDataModel getListaPedidoModel() {
        return listaPedidoModel;
    }

    public void setListaPedidoModel(PedidoDataModel listaPedidoModel) {
        this.listaPedidoModel = listaPedidoModel;
    }

    public PedidoDataModel getListaPedidosHistoricoModel() {
        return listaPedidosHistoricoModel;
    }

    public void setListaPedidosHistoricoModel(PedidoDataModel listaPedidosHistoricoModel) {
        this.listaPedidosHistoricoModel = listaPedidosHistoricoModel;
    }

    public List<Produto> getListaProdutosPedido() {
        return listaProdutosPedido;
    }

    public void setListaProdutosPedido(List<Produto> listaProdutosPedido) {
        this.listaProdutosPedido = listaProdutosPedido;
    }

    public Pedido getPedidoEmAtendimento() {
        return pedidoEmAtendimento;
    }

    public void setPedidoEmAtendimento(Pedido pedidoEmAtendimento) {
        this.pedidoEmAtendimento = pedidoEmAtendimento;
    }
    
    public List<Pedido> getListaPedidosEmAbertoPorMesa() {
        return listaPedidosEmAbertoPorMesa;
    }

}
